/**
 * Created by mapbar_front on 2019/5/23.
 */

import React,{Component} from 'react';

/*继承*/
//两种继承：接口继承和实现继承
// ECMAScript描述了原型链的概念，并将原型链作为实现继承的主要方法。其基本思想是：
// 利用原型让一个类型继承另一个类型的属性和方法。

/*原型链*/
/*
function SuperType(name){
    this.property = '父类';
    this.name = name;
}
SuperType.prototype.getSuperValue = function() {
    return this.property;
}

function SubType(){
    this.subProperty = '子类';
}
//继承了SuperType
SubType.prototype = new SuperType('tianxia');

var sub = new SubType();

SubType.prototype.getSubValue = function(){
    return this.subProperty;
}
//子类继承了父类的方法
console.log(sub.getSuperValue()); //父类
//子类继承了父类的属性
console.log(sub.name);

console.log(sub.constructor); //SuperType 这是因为SubType.prototype 被改写的缘故。

console.log(sub.getSubValue());

//所有函数的默认原型都是Object的实例。
console.log(SuperType.prototype instanceof Object); //true
console.log(new Object());
//因此函数默认原型都包含一个内部指针，指向Object.prototype。
console.log(new Object().__proto__ == Object.prototype);

console.log(typeof sub.toString); //function

//所有函数的默认原型都是Object实例。
console.log(SuperType.prototype);

function Super(){}
var super1 = new Super();
//构造函数的原型和实例的__proto__是否指向同一个对象？
console.log(Super.prototype == super1.__proto__); //true
//构造函数的原型是什么？
console.log(Super.prototype);

//所有函数的默认原型都是Object实例？？？
function Person(){}
console.log(Person.prototype instanceof Object); //true
//如何证明？？？

console.log(Person.prototype == new Object().__proto__); //这是为何？

// 2.确定原型和实例的关系
// 可以通过两种方式确定实例和原型之间的关系
// 第一种方式是使用instanceof操作符，只要用这个操作符 测试实例与原型链中出现的构造函数，结构就会返回true。



console.log(SuperType.prototype instanceof Object); //true
console.log(sub instanceof SuperType); //true
console.log(sub instanceof Object); //true
//SubType.prototype == new SuperType();
console.log(sub instanceof SubType); //true

//isPrototypeOf 只要是原型链中出现过的原型，都可以说该原型链所派生的实例的原型。
console.log(Object.prototype.isPrototypeOf(sub));       //true
console.log(SuperType.prototype.isPrototypeOf(sub));    //true
console.log(SubType.prototype.isPrototypeOf(sub));      //true

function SuperType(){
    this.property = '超类';
}
SuperType.prototype.getSuperValue = function(){
    return this.property;
}

function SubType(){
    this.subproperty = '子类'
}
SubType.prototype = new SuperType();

// SubType.prototype = {
//     getSubValue: function() {
//         return this.subProperty;
//     }
// }

//添加新方法
SubType.prototype.getSubValue = function() {
    return this.subproperty;
}
SubType.prototype.getSuperValue = function() {
    return this.property = '重写超类';
}
var instance = new SubType();
console.log(instance.getSuperValue());
console.log(new SuperType().getSuperValue()); //超类

function SuperType(){
    this.colors = ['yellow','blue'];
}
function SubType(){}
SubType.prototype = new SuperType();
var instance1 = new SubType();
var instance2 = new SubType();

instance1.colors.push('green');
console.log(instance1.colors);
console.log(instance2.colors);

//借用构造函数
function SuperType(name,age){
    this.colors = ['yellow','blue'];
    this.name = name;
    this.age = age;
}
SuperType.prototype.sayName = function() {
    console.log(this.name);
}
function SubType(){
    SuperType.call(this,'woaini',22);
    this.age = 18;
}
SubType.prototype  = new SuperType();

var instance1 = new SubType(18);
instance1.colors.push('green');
console.log(instance1.colors);
console.log(instance1.name);
console.log(instance1.age);
//在超类型原型定义的方法，对于子类型而言也是不可见的。
//console.log(instance1.sayName()); //undefined

var instance2 = new SubType();
console.log(instance2.colors);
console.log(instance2.age);

//组合继承
function SuperType(name){
    this.name = name;
    this.age = 123456;
    this.colors = ['yellow','red'];
}

console.log('******************');
function SubType(name,age){
    //继承，并传参数
    SuperType.call(this,name);
    this.age = age;
}
SuperType.prototype.sayName = function(){
    console.log(this.name);
}
SuperType.prototype.sayAge = function(){
    console.log(this.age);
}
SubType.prototype = new SubType();
//下面这行代码该如何理解？

SubType.prototype.constructor = SubType;
console.log('SubType.prototype',SubType.prototype.constructor);

var instance1 = new SubType('tianxia123',123);
instance1.colors.push('blue');
console.log(instance1.colors);
instance1.sayName();
instance1.sayAge();

var instance2 = new SubType('xiaoxiao456',456);
console.log(instance2.colors);
instance2.sayName();
instance2.sayAge();
*/

function object(){
    return Object.assign({},{name:'tianxia',colors:['red']})
}

var otherPerson = object();
console.log(otherPerson);
otherPerson.name = 'tianxia666';
console.log(otherPerson);







class Inherit extends Component{
    constructor(props){
        super(props);
    }
    render(){
        return (
            <div>Inherit</div>
        )
    }
}
export default Inherit;